package com.ics.atable.chat.service.impl;

import com.ics.atable.chat.config.AiExplanationProperties;
import com.ics.atable.chat.model.dto.SqlReplaceDTO;
import com.ics.atable.chat.model.entity.DataCellWide;
import com.ics.atable.chat.service.AiExplanationService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Service;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.stream.Collectors;

/**
 * AI 解释服务实现类
 *
 * @author system
 */
@Service
@Slf4j
public class AiExplanationServiceImpl implements AiExplanationService {

    @Autowired
    private ChatClient chatClient;

    @Autowired
    private AiExplanationProperties aiProperties;

    // 提示词模板缓存
    private String emptyPromptTemplate = null;
    private String singlePromptTemplate = null;
    private String multiplePromptTemplate = null;

    @Override
    public String generateExplanation(
            SqlReplaceDTO.QueryRequest.ReplaceParams queryParams,
            List<DataCellWide> results) {

        // 检查 AI 功能是否启用
        if (!aiProperties.isEnabled()) {
            log.info("AI 功能已禁用，使用固定模板");
            return generateFallbackExplanation(queryParams, results);
        }

        try {
            // 构造提示词
            String prompt = buildPrompt(queryParams, results);
            log.debug("AI 提示词: {}", prompt);

            // 调用 AI 生成解释
            long startTime = System.currentTimeMillis();
            String explanation = chatClient.prompt()
                    .user(prompt)
                    .call()
                    .content();
            long duration = System.currentTimeMillis() - startTime;

            log.info("AI 生成解释成功，耗时: {}ms", duration);
            return explanation;

        } catch (Exception e) {
            log.error("AI 生成解释失败，使用降级方案", e);

            // 降级到固定模板
            if (aiProperties.isFallbackEnabled()) {
                return generateFallbackExplanation(queryParams, results);
            } else {
                throw new RuntimeException("AI 服务不可用且降级功能已禁用", e);
            }
        }
    }

    /**
     * 加载提示词模板
     *
     * @param templateName 模板文件名
     * @return 提示词模板内容
     */
    private String loadPromptTemplate(String templateName) {
        try {
            ClassPathResource resource = new ClassPathResource("prompts/" + templateName);
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(resource.getInputStream(), StandardCharsets.UTF_8))) {
                String template = reader.lines().collect(Collectors.joining("\n"));
                log.info("成功加载提示词模板: {}", templateName);
                return template;
            }
        } catch (Exception e) {
            log.error("加载提示词模板失败: {}", templateName, e);
            return null;
        }
    }

    /**
     * 构造 AI 提示词
     *
     * @param queryParams 查询参数
     * @param results 查询结果
     * @return 提示词
     */
    private String buildPrompt(
            SqlReplaceDTO.QueryRequest.ReplaceParams queryParams,
            List<DataCellWide> results) {

        String template = null;
        
        // 根据结果数量选择模板
        if (results.isEmpty()) {
            if (emptyPromptTemplate == null) {
                emptyPromptTemplate = loadPromptTemplate("data_explanation_empty.txt");
            }
            template = emptyPromptTemplate;
        } else if (results.size() == 1) {
            if (singlePromptTemplate == null) {
                singlePromptTemplate = loadPromptTemplate("data_explanation_single.txt");
            }
            template = singlePromptTemplate;
        } else {
            if (multiplePromptTemplate == null) {
                multiplePromptTemplate = loadPromptTemplate("data_explanation_multiple.txt");
            }
            template = multiplePromptTemplate;
        }
        
        // 如果模板加载失败，使用默认逻辑
        if (template == null) {
            return buildPromptFallback(queryParams, results);
        }
        
        // 替换模板中的占位符
        String prompt = template
                .replace("{fullItemName}", queryParams.getFullItemName())
                .replace("{fullColumnName}", queryParams.getFullColumnName())
                .replace("{tableYear}", queryParams.getTableYear())
                .replace("{taskQuarter}", queryParams.getTaskQuarter())
                .replace("{fullOrgName}", queryParams.getFullOrgName());
        
        // 根据不同情况替换结果相关的占位符
        if (results.size() == 1) {
            DataCellWide result = results.get(0);
            prompt = prompt
                    .replace("{resultOrgName}", result.getFullOrgName())
                    .replace("{resultValue}", result.getCellValue() != null ? result.getCellValue() : "数据缺失");
        } else if (results.size() > 1) {
            StringBuilder resultList = new StringBuilder();
            for (int i = 0; i < results.size(); i++) {
                DataCellWide result = results.get(i);
                String value = result.getCellValue() != null ? result.getCellValue() : "数据缺失";
                resultList.append(String.format("%d. %s：%s\n", i + 1, result.getFullOrgName(), value));
            }
            prompt = prompt
                    .replace("{resultCount}", String.valueOf(results.size()))
                    .replace("{resultList}", resultList.toString());
        }
        
        return prompt;
    }

    /**
     * 降级方案：模板加载失败时的简单提示
     * 注意：正常情况下不应该走到这里，如果走到这里说明模板文件配置有问题
     *
     * @param queryParams 查询参数
     * @param results 查询结果
     * @return 简单的提示词
     */
    private String buildPromptFallback(
            SqlReplaceDTO.QueryRequest.ReplaceParams queryParams,
            List<DataCellWide> results) {
        
        log.error("提示词模板加载失败，使用最简化的降级方案");
        
        // 构建最基本的提示词
        StringBuilder prompt = new StringBuilder();
        prompt.append("请用中文解释以下数据查询结果：\n\n");
        prompt.append(String.format("查询条件：%s年第%s季度，%s的%s，查询范围：%s\n\n",
                queryParams.getTableYear(),
                queryParams.getTaskQuarter(),
                queryParams.getFullItemName(),
                queryParams.getFullColumnName(),
                queryParams.getFullOrgName()));
        
        if (results.isEmpty()) {
            prompt.append("查询结果：未找到数据\n");
        } else if (results.size() == 1) {
            DataCellWide result = results.get(0);
            prompt.append(String.format("查询结果：%s - %s\n",
                    result.getFullOrgName(),
                    result.getCellValue()));
        } else {
            prompt.append(String.format("查询结果：共%d条记录\n", results.size()));
            for (int i = 0; i < results.size(); i++) {
                DataCellWide result = results.get(i);
                prompt.append(String.format("%d. %s：%s\n",
                        i + 1,
                        result.getFullOrgName(),
                        result.getCellValue() != null ? result.getCellValue() : "数据缺失"));
            }
        }
        
        prompt.append("\n请生成简洁专业的中文解释。");
        
        return prompt.toString();
    }

    /**
     * 降级方案：使用固定模板生成解释
     *
     * @param queryParams 查询参数
     * @param results 查询结果
     * @return 固定模板生成的解释
     */
    private String generateFallbackExplanation(
            SqlReplaceDTO.QueryRequest.ReplaceParams queryParams,
            List<DataCellWide> results) {

        log.info("使用固定模板生成解释");

        // 场景 1：空结果
        if (results.isEmpty()) {
            return String.format("未找到关于%s在%s年第%s季度%s的相关数据。",
                    queryParams.getFullItemName(),
                    queryParams.getTableYear(),
                    queryParams.getTaskQuarter(),
                    queryParams.getFullColumnName());
        }

        StringBuilder explanation = new StringBuilder();

        // 场景 2：单条记录
        if (results.size() == 1) {
            DataCellWide result = results.get(0);
            explanation.append(String.format("查询结果显示：在%s年第%s季度，%s地区的%s%s为%s。",
                    result.getTableYear(),
                    result.getTaskQuarter(),
                    result.getFullOrgName(),
                    result.getFullItemName(),
                    result.getFullColumnName(),
                    result.getCellValue()));
        }
        // 场景 3：多条记录
        else {
            explanation.append(String.format("查询到%d条相关记录：", results.size()));

            // 列出所有记录
            for (int i = 0; i < results.size(); i++) {
                DataCellWide result = results.get(i);
                explanation.append(String.format("\n%d. %s地区：%s",
                        i + 1,
                        result.getFullOrgName(),
                        result.getCellValue()));
            }

            // 添加汇总说明
            explanation.append(String.format("\n\n以上数据均为%s年第%s季度%s的%s。",
                    queryParams.getTableYear(),
                    queryParams.getTaskQuarter(),
                    queryParams.getFullItemName(),
                    queryParams.getFullColumnName()));
        }

        return explanation.toString();
    }

    @Override
    public boolean isAiAvailable() {
        if (!aiProperties.isEnabled()) {
            return false;
        }

        try {
            // 发送简单的测试请求
            String response = chatClient.prompt()
                    .user("测试")
                    .call()
                    .content();
            return response != null && !response.isEmpty();
        } catch (Exception e) {
            log.warn("AI 服务不可用: {}", e.getMessage());
            return false;
        }
    }
}
